let { User,Message,Comment } = require('../models');
const auth = require('../utils/auth');
// 显示首页
let index_fn = async (ctx, next) => {
    let username=ctx.session.userName;
    let userIds=[];
    // 所有的说说
    let msgs=JSON.parse(JSON.stringify(await Message.findAll({
        order:[
            ['id','desc']
        ]
    })));

    // 查询出来的说说的id（如果有分页，则应该是10条说说的id）
    let msgIds=[];

    msgs.forEach(item=>{
        msgIds.push(item.id);
        userIds.push(item.fromUserId);
    });


    // 所有的吐槽（如果有分页，可以根据查出来的说说的id，来查询所对应的所有的吐槽）
    let comments=JSON.parse(JSON.stringify(await Comment.findAll({
        where:{
            msgId:msgIds
        }
    })));

    comments.forEach(item=>{
        userIds.push(item.fromUserId);
    });

    let userAll=await User.findAll({
        where:{
            id:userIds
        }
    });

    // 遍历所有的评论，给每一个评论的fromUserId加上用户名称
    comments.forEach(item=>{
        let userInfo=userAll.filter(row=>{
            return item.fromUserId===row.id;
        })[0];
        item.comUserName=userInfo===undefined?'匿名': userInfo.username;
    })

    // 组合成上下级关系
    msgs.forEach(msg=>{
        let sayComments=comments.filter(item=>{
            return item.msgId===msg.id;
        });
        let userInfo=userAll.filter(row=>{
            return msg.fromUserId===row.id;
        })[0];
        msg.msgUserName=userInfo===undefined?'匿名': userInfo.username;
        msg.comments=sayComments;
    })


    let obj={
        username,
        msgs
    };
    ctx.render('index.html',obj);
};
// 显示登录界面
let login_fn = async (ctx, next) => {
    ctx.render('login.html');
};
// 显示注册界面
let register_fn = async (ctx, next) => {
    ctx.render('register.html', { msg: '' });
};
// 处理登录请求
let loginDone_fn = async (ctx, next) => {
    // 获取从前端传来的数据（用户信息）
    let uid = ctx.request.body.username.trim() || '';
    let pwd = ctx.request.body.password.trim() || '';

    let res='';

    if (uid.length > 0 && pwd.length > 0) {
        let row = await User.findOne({
            where: {
                username: uid,
                password:pwd
            }
        });
        let u2Json = JSON.stringify(row);
        if(u2Json!=='null'){
            ctx.session.userId=row.id;
            ctx.session.userName=row.username;
            res={code:200,msg:'登录成功'};
        }else{
            res={code:1000,msg:'用户名或密码错误，请确认后重试'};
        }
        
    }else{
        res={code:1000,msg:'用户名和密码不能为空'};
    }
    ctx.body=JSON.stringify(res);
};
// 处理注册请求
let registerDone_fn = async (ctx, next) => {
    // 获取从前端传来的数据（用户信息）
    let uid = ctx.request.body.username.trim() || '';
    let pwd = ctx.request.body.password.trim() || '';
    let confirmpwd = ctx.request.body.confirmpassword.trim() || '';

    let res = '';

    // 判断用户名、密码是否为空，为空则返回提示信息；不为空则尝试从数据库中查询是否有同名用户，如果没有，则创建用户；如果有，则返回提示信息；
    // 初步尝试then的玩法，出现了一些顺序问题（前端获取的返回数据为空的情况）
    if (uid.length > 0 && pwd.length > 0 && pwd === confirmpwd) {
        let row = await User.findOne({
            where: {
                username: uid
            }
        });
        let u2Json = JSON.stringify(row);
        if (u2Json === 'null') {
            let u1 = await User.create({
                username: uid,
                password: pwd
            });
            let u1Json = JSON.stringify(u1);
            if (u1Json !== 'null') {
                res = { code: 200, msg: '用户注册成功' };
            } else {
                res = { code: 1000, msg: '因为服务器或者网络原因，用户未注册成功' };
            }
        } else {
            res = { code: 1000, msg: '当前用户名已经注册，请确认后重试' };
        }
    } else {
        res = { code: 1000, msg: '用户名和密码不能为空，且两密码应该一致' };
    }
    // 返回消息
    ctx.body = JSON.stringify(res);
};
// 注销
let logout_fn=async (ctx,next)=>{
    ctx.session=null;
    ctx.body={code:200,msg:'注销成功'};
}
// 说说调用的方法
let say_fn=async (ctx,next)=>{
    let sayMsg=ctx.request.body.sayMsg || '';
    let userId=ctx.session.userId;
    let say=await Message.create({
        fromUserId:userId,
        content:sayMsg
    });

    let data=JSON.stringify(say);

    ctx.body={code:200,data,msg:'发表说说成功'};
}
// 吐槽一下调用的方法
let comment_fn=async (ctx,next)=>{
    let commentMsg=ctx.request.body.commentMsg || '';
    let msgId=ctx.request.body.msgId || '';
    let fromUserId=ctx.session.userId;

    // 将评论的信息插入数据库
    let comment=await Comment.create({
        fromUserId:fromUserId,
        msgId:msgId,
        content:commentMsg
    });

    // 因为要查找说说的用户信息，所以这里先查询了说说的信息，拿到发表说说的用户的id
    let msg=await Message.findOne({
        where:{
            id:msgId
        }
    });

    let toUserId=msg===undefined?'0':msg.fromUserId;

    // 在用户表里查询发表说说的用户的信息和发表评论的用户的信息
    let users=await User.findAll({
        where:{
            id:[fromUserId,toUserId]
        }
    });

    // 根据评论者的id，查询到说说的用户信息
    var fromUserInfo=JSON.parse(JSON.stringify(users.filter(user=>{
        return user.id===fromUserId;
    })[0]));

    // 根据发表说说的id，查询到评论的用户信息
    var toUserInfo=JSON.parse(JSON.stringify(users.filter(user=>{
        return user.id===toUserId;
    })[0]));


    let data=JSON.parse(JSON.stringify(comment));

    // 将说说的用户名称和评论的用户名称挂载到数据信息里面，返回前端
    data.fromUserName=fromUserInfo.username;
    data.toUserName=toUserInfo.username;

    ctx.body={code:200,data,msg:'吐槽成功'};
}


module.exports = {
    '/': ['get',auth, index_fn],
    '/login': ['get',auth, login_fn],
    '/logout': ['post',auth, logout_fn],
    '/register': ['get', register_fn],
    '/loginDone': ['post', loginDone_fn],
    '/registerDone': ['post', registerDone_fn],
    '/say': ['post', say_fn],
    '/comment': ['post', comment_fn],
}